/**
 * @description 判读是否为外链
 * @param {string} path
 * @returns {Boolean}
 */
export function isExternal(path) {
  return /^(https?:|mailto:|tel:)/.test(path)
}

/**
 * @param {string} str
 * @returns {Boolean}
 */
export function validUsername(str) {
  const valid_map = ['admin', 'editor']
  return valid_map.indexOf(str.trim()) >= 0
}

/**
 * @description 校验密码是否小于6位
 * @param str
 * @returns {boolean}
 */
export function isPassword(str) {
  return str.length >= 6
}

/**
 * @description 判断是否是字符串
 * @param str
 * @returns {boolean}
 */
export function isString(str) {
  return typeof str === 'string' || str instanceof String
}

/**
 * @description 判断是否是数字
 * @param  str
 * @returns  {boolean}
 */
export function isNumber(str) {
  return !isNaN(str)
}

/**
 * @description 判断是否是字符串，是就转换数字
 * @param {any} value
 * @returns {any}
 */
export function convertToNumberOrKeep(value) {
  if (typeof value === 'string') {
    if (value === '') {
      return 0
    }
    const number = Number(value)
    if (isNaN(number)) {
      return value
    }
    return number
  }
  return value
}
/**
 * @description 判断是否是数字，是就转换字符串
 * @param {any} value
 */
export function convertToStringOrKeep(value) {
  if (typeof value === 'number') {
    return String(value)
  }
  return value
}

/**
 * @description 判断是否是null，是就转换为空字符串
 * @param {any} value
 * @param {*} defaultValue 默认空
 * @returns
 */
export function convertToStringOrEmpty(value, defaultValue = '') {
  return value == null || value === '' || Number.isNaN(value) ? defaultValue : String(value)
}

/**
 * @description 判断是否是数组
 * @param arg
 * @returns {arg is any[]|boolean}
 */
export function isArray(arg) {
  if (typeof Array.isArray === 'undefined') {
    return Object.prototype.toString.call(arg) === '[object Array]'
  }
  return Array.isArray(arg)
}

/**
 * @description 判断是否是手机号
 * @param str
 * @returns {boolean}
 */
export function isPhone(str) {
  const reg = /^1\d{10}$/
  return reg.test(str)
}

//是否为NULL
export function isNull(value) {
  if (value == null || typeof value == 'undefined' || value === undefined) {
    return true
  }
  return false
}

//是否为空(包括空字符串、空格、null,{})
export function isEmpty(strings) {
  if (!this.isNull(strings)) {
    // 先判断是否为null，返回true ，判断是否为空字符串，返回true
    // 空对象
    if (strings instanceof Object) {
      if (JSON.stringify(strings) == '{}') {
        return true
      }
    }
    if ((strings + '').replace(/(^\s*)|(\s*$)/g, '').length === 0) {
      //已修正bug[当strings为数字时，会报strings.replace is not a function]
      return true
    }
  } else {
    return true
  }
  // 不为空返回false
  return false
}
//是否为中文
export function isChinese(temp) {
  var re = /[^\u4E00-\u9FA5]/
  if (re.test(temp)) return false
  return true
}

//是否为邮箱
export function isEmail(email) {
  return /^([a-zA-Z0-9_-])+@([a-zA-Z0-9_-])+((.[a-zA-Z0-9_-]{2,3}){1,2})$/.test(email)
}
//邮箱验证
export function validateEmail(email) {
  const regex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/
  return regex.test(email)
}

//格式化值
export function formatValueByKey(value, list, key, returnKey) {
  if (value && list && list.length > 0) {
    const item = list.find(item => item[key] === value)
    return item ? item[returnKey] : ''
  }
}

// 首字母大小
export function titleCase(str) {
  return str.replace(/( |^)[a-z]/g, L => L.toUpperCase())
}

// 下划转驼峰
export function camelCase(str) {
  return str.replace(/_[a-z]/g, str1 => str1.substr(-1).toUpperCase())
}

export function isNumberStr(str) {
  return /^[+-]?(0|([1-9]\d*))(\.\d+)?$/g.test(str)
}

// -转驼峰
export function toCamelCase(str, upperCaseFirst) {
  str = (str || '').toLowerCase().replace(/-(.)/g, function (match, group1) {
    return group1.toUpperCase()
  })

  if (upperCaseFirst && str) {
    str = str.charAt(0).toUpperCase() + str.slice(1)
  }

  return str
}

export function debounce(func, wait, immediate) {
  let timeout, args, context, timestamp, result

  const later = function () {
    // 据上一次触发时间间隔
    const last = +new Date() - timestamp

    // 上次被包装函数被调用时间间隔 last 小于设定时间间隔 wait
    if (last < wait && last > 0) {
      timeout = setTimeout(later, wait - last)
    } else {
      timeout = null
      // 如果设定为immediate===true，因为开始边界已经调用过了此处无需调用
      if (!immediate) {
        result = func.apply(context, args)
        if (!timeout) context = args = null
      }
    }
  }

  return function (...args) {
    context = this
    timestamp = +new Date()
    const callNow = immediate && !timeout
    // 如果延时不存在，重新设定延时
    if (!timeout) timeout = setTimeout(later, wait)
    if (callNow) {
      result = func.apply(context, args)
      context = args = null
    }
    return result
  }
}

export function deepClone(obj) {
  let objClone = Array.isArray(obj) ? [] : {}
  if (obj && typeof obj === 'object') {
    for (var key in obj) {
      // eslint-disable-next-line no-prototype-builtins
      if (obj.hasOwnProperty(key)) {
        if (obj[key] && typeof obj[key] === 'object') {
          objClone[key] = deepClone(obj[key])
        } else {
          objClone[key] = obj[key]
        }
      }
    }
  }
  return objClone
}
